package com.tbit.main.util;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.text.StrPool;
import cn.hutool.core.util.StrUtil;

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * @author LMY
 * @create 2021-04-01 15:42
 */
public class ListUtil {

    /**
     * 获取第一个存在，第二个不存在的列表
     *
     * @param list1
     * @param list2
     * @return
     */
    public static List<Integer> getSameIntegerList(List<Integer> list1, List<Integer> list2) {
        //开始分离
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (Integer integer : list1) {
            map.put(integer, 1);
        }
        for (Integer integer : list2) {
            map.put(integer, 2);
        }
        List<Integer> list3 = new ArrayList<Integer>();
        Set<Map.Entry<Integer, Integer>> entrySet = map.entrySet();
        for (Map.Entry<Integer, Integer> entry : entrySet) {
            Integer value = entry.getValue();
            if (Objects.equals(1, value)) {
                list3.add(entry.getKey());
            }
        }
        return list3;
    }

    /**
     * 获取第一个存在，第二个不存在的列表
     *
     * @param list1
     * @param list2
     * @return
     */
    public static Set<String> getSameIntegerSet(Set<String> list1, List<String> list2) {
        //开始分离
        Map<String, Integer> map = new HashMap<String, Integer>();
        for (String integer : list1) {
            map.put(integer, 1);
        }
        for (String integer : list2) {
            map.put(integer, 2);
        }
        Set<String> list3 = new HashSet<>();
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        for (Map.Entry<String, Integer> entry : entrySet) {
            Integer value = entry.getValue();
            if (Objects.equals(1, value)) {
                list3.add(entry.getKey());
            }
        }
        return list3;
    }

    /**
     * 获取第一个存在，第二个不存在的列表
     *
     * @param list1
     * @param list2
     * @return
     */
    public static List<String> getSameString(List<String> list1, List<String> list2) {
        //开始分离
        Map<String, Integer> map = new HashMap<String, Integer>();
        for (String integer : list1) {
            map.put(integer, 1);
        }
        for (String integer : list2) {
            map.put(integer, 2);
        }
        List<String> list3 = new LinkedList<>();
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        for (Map.Entry<String, Integer> entry : entrySet) {
            Integer value = entry.getValue();
            if (Objects.equals(1, value)) {
                list3.add(entry.getKey());
            }
        }
        return list3;
    }

    /**
     * 获取第二个存在，第一个不存在的列表
     *
     * @param list1
     * @param list2
     * @return
     */
    public static List<Integer> getDifferentIntegerList(List<Integer> list1, List<Integer> list2) {
        //开始分离
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (Integer integer : list2) {
            map.put(integer, 1);
        }
        for (Integer integer : list1) {
            map.put(integer, 2);
        }
        List<Integer> list3 = new ArrayList<Integer>();
        Set<Map.Entry<Integer, Integer>> entrySet = map.entrySet();
        for (Map.Entry<Integer, Integer> entry : entrySet) {
            Integer value = entry.getValue();
            if (Objects.equals(1, value)) {
                list3.add(entry.getKey());
            }
        }
        return list3;
    }

    /**
     * 获取相同集合
     *
     * @param firstArrayList
     * @param secondArrayList
     * @return
     */
    public static List<Integer> receiveCollectionList(List<Integer> firstArrayList, List<Integer> secondArrayList) {

        if (firstArrayList == null || secondArrayList == null) {
            return null;
        }

        List<Integer> resultList = new ArrayList<Integer>();
        // 大集合用linkedlist
        LinkedList<Integer> result = new LinkedList<Integer>(firstArrayList);
        // 小集合用hashset
        HashSet<Integer> othHash = new HashSet<Integer>(secondArrayList);
        // 采用Iterator迭代器进行数据的操作
        Iterator<Integer> iter = result.iterator();
        while (iter.hasNext()) {
            if (!othHash.contains(iter.next())) {
                iter.remove();
            }
        }
        resultList = new ArrayList<Integer>(result);
        return resultList;
    }

    /**
     * 多个集合的非重复并集，类似于SQL中的“UNION DISTINCT”<br>
     * 针对一个集合中存在多个相同元素的情况，只保留一个<br>
     * 例如：集合1：[a, b, c, c, c]，集合2：[a, b, c, c]<br>
     * 结果：[a, b, c]，此结果中只保留了一个c
     *
     * @param <T>   集合元素类型
     * @param coll1 集合1
     * @param coll2 集合2
     * @return 并集的集合，返回 {@link LinkedHashSet}
     */
    public static <T> Set<T> unionDistinct(Collection<T> coll1, Collection<T> coll2) {

        if (CollUtil.isEmpty(coll1) || CollUtil.isEmpty(coll2)) {
            return Collections.emptySet();
        }

        return coll1.stream().filter(coll2::contains).collect(Collectors.toSet());
    }

    public static <T> List<T> convertList(String string, Function<String, T> converter) {
        if (StrUtil.isBlank(string)) {
            return Collections.emptyList();
        }
        String[] strArr = string.trim().split(StrPool.COMMA);
        List<T> list = new ArrayList<>(strArr.length);
        for (String s : strArr) {
            T item = converter.apply(s.trim());
            list.add(item);
        }
        return list;
    }
}
